// 写入数据集成文件
const client = require("../db.js");
const db = client.db(global.config.db.name); // 获取数据库对象

let readData = (query, dbName, isOne = false) => {
  // query 查询条件
  //   - 支持排序参数: { sort: { field: 1或-1 } }，1表示升序，-1表示降序
  // dbName 集合名称
  // isOne 是否查询单条数据
  return new Promise(async (resolve, reject) => {
    // 辅助函数：判断是否为对象
    function isObject(prop) {
      return prop !== null && typeof prop === "object";
    }

    // 参数验证
    if (!isObject(query)) {
      reject("查询条件必须是对象");
      return;
    }

    if (!dbName || typeof dbName !== "string") {
      reject("集合名称必须是字符串");
      return;
    }

    // 复制查询条件，避免修改原对象
    const queryParams = { ...query };

    // 提取并验证分页参数
    let page = parseInt(queryParams.page, 10) || 1;
    let size = parseInt(queryParams.size, 10) || 10;

    // 确保分页参数为有效正整数
    page = Math.max(1, isNaN(page) ? 1 : page);
    size = Math.max(1, Math.min(1000, isNaN(size) ? 10 : size)); // 限制最大页大小为1000

    // 提取排序参数 - 新增核心逻辑
    let sortOption = { createTime: -1 }; // 默认按创建时间倒序
    if (queryParams.sort && isObject(queryParams.sort)) {
      // 如果传入了有效的排序参数，则使用传入的排序方式
      sortOption = queryParams.sort;
    }

    // 移除不需要的参数
    delete queryParams.page;
    delete queryParams.size;
    delete queryParams.total;
    delete queryParams.sort; // 移除排序参数，避免影响查询条件

    // 处理空值查询条件
    for (let k in queryParams) {
      if (queryParams[k] === undefined || queryParams[k] === null || queryParams[k] === '') {
        delete queryParams[k];
      }
    }

    // 处理数组查询条件
    const filterParams = {};
    for (const key in queryParams) {
      if (Array.isArray(queryParams[key])) {
        filterParams[key] = { $in: queryParams[key] };
      } else {
        filterParams[key] = queryParams[key];
      }
    }

    const collection = db.collection(dbName); // 获取集合对象
    const skip = (page - 1) * size; // 计算需要跳过的文档数

    try {
      if (isOne) {
        // 单条数据查询，使用指定的排序方式
        const document = await collection.findOne(filterParams, {
          sort: sortOption
        });
        resolve({
          code: 20000,
          data: document || {},
          msg: "操作成功",
        });
      } else {
        // 多条数据查询
        // 先获取总条数
        const totalDocuments = await collection.countDocuments(filterParams);

        // 计算实际有效的skip值，防止超出范围
        const validSkip = Math.min(skip, Math.max(0, totalDocuments - size));

        // 查询数据，使用指定的排序方式
        const documents = await collection
          .find(filterParams)
          .sort(sortOption)
          .skip(validSkip)
          .limit(size)
          .toArray();

        resolve({
          code: 20000,
          data: documents,
          msg: "操作成功",
          total: totalDocuments,
          page,
          size,
          totalPages: Math.ceil(totalDocuments / size) || 1,
          hasMore: page < Math.ceil(totalDocuments / size),
          sort: sortOption // 返回实际使用的排序方式
        });
      }
    } catch (error) {
      reject(`查询失败: ${error.message}`);
    }
  });
};

module.exports = readData;
